{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install pyvirtualdisplay\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 07. N-Step Learning\n",
    "\n",
    "[R. S. Sutton, \"Learning to predict by the methods of temporal differences.\" Machine learning, 3(1):9–44, 1988.](http://incompleteideas.net/papers/sutton-88-with-erratum.pdf)\n",
    "\n",
    "Q-learning accumulates a single reward and then uses the greedy action at the next step to bootstrap. Alternatively, forward-view multi-step targets can be used (Sutton 1988). We call it Truncated N-Step Return\n",
    "from a given state $S_t$. It is defined as,\n",
    "\n",
    "$$\n",
    "R^{(n)}_t = \\sum_{k=0}^{n-1} \\gamma_t^{(k)} R_{t+k+1}.\n",
    "$$\n",
    "\n",
    "A multi-step variant of DQN is then defined by minimizing the alternative loss,\n",
    "\n",
    "$$\n",
    "(R^{(n)}_t + \\gamma^{(n)}_t \\max_{a'} q_{\\theta}^{-}\n",
    "(S_{t+n}, a')\n",
    "- q_{\\theta}(S_t, A_t))^2.\n",
    "$$\n",
    "\n",
    "Multi-step targets with suitably tuned $n$ often lead to faster learning (Sutton and Barto 1998)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from collections import deque\n",
    "from typing import Deque, Dict, List, Tuple\n",
    "\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer for N-step learning\n",
    "\n",
    "There are a little bit changes in Replay buffer for N-step learning. First, we use `deque` to store the most recent n-step transitions.\n",
    "\n",
    "```python\n",
    "    self.n_step_buffer = deque(maxlen=n_step)\n",
    "```\n",
    "\n",
    "You can see it doesn't actually store a transition in the buffer, unless `n_step_buffer` is full.\n",
    "\n",
    "```\n",
    "    # in store method\n",
    "    if len(self.n_step_buffer) < self.n_step:\n",
    "        return ()\n",
    "```\n",
    "\n",
    "When the length of `n_step_buffer` becomes equal to N, it eventually stores the N-step transition, which is calculated by `_get_n_step_info` method.\n",
    "\n",
    "(Please see *01.dqn.ipynb* for detailed description of the basic replay buffer.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        obs_dim: int, \n",
    "        size: int, \n",
    "        batch_size: int = 32, \n",
    "        n_step: int = 3, \n",
    "        gamma: float = 0.99,\n",
    "    ):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "        \n",
    "        # for N-step Learning\n",
    "        self.n_step_buffer = deque(maxlen=n_step)\n",
    "        self.n_step = n_step\n",
    "        self.gamma = gamma\n",
    "\n",
    "    def store(\n",
    "        self, \n",
    "        obs: np.ndarray, \n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool\n",
    "    ) -> Tuple[np.ndarray, np.ndarray, float, np.ndarray, bool]:\n",
    "        transition = (obs, act, rew, next_obs, done)\n",
    "        self.n_step_buffer.append(transition)\n",
    "\n",
    "        # single step transition is not ready\n",
    "        if len(self.n_step_buffer) < self.n_step:\n",
    "            return ()\n",
    "        \n",
    "        # make a n-step transition\n",
    "        rew, next_obs, done = self._get_n_step_info(\n",
    "            self.n_step_buffer, self.gamma\n",
    "        )\n",
    "        obs, act = self.n_step_buffer[0][:2]\n",
    "        \n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "        \n",
    "        return self.n_step_buffer[0]\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        indices = np.random.choice(\n",
    "            self.size, size=self.batch_size, replace=False\n",
    "        )\n",
    "\n",
    "        return dict(\n",
    "            obs=self.obs_buf[indices],\n",
    "            next_obs=self.next_obs_buf[indices],\n",
    "            acts=self.acts_buf[indices],\n",
    "            rews=self.rews_buf[indices],\n",
    "            done=self.done_buf[indices],\n",
    "            # for N-step Learning\n",
    "            indices=indices,\n",
    "        )\n",
    "    \n",
    "    def sample_batch_from_idxs(\n",
    "        self, indices: np.ndarray\n",
    "    ) -> Dict[str, np.ndarray]:\n",
    "        # for N-step Learning\n",
    "        return dict(\n",
    "            obs=self.obs_buf[indices],\n",
    "            next_obs=self.next_obs_buf[indices],\n",
    "            acts=self.acts_buf[indices],\n",
    "            rews=self.rews_buf[indices],\n",
    "            done=self.done_buf[indices],\n",
    "        )\n",
    "    \n",
    "    def _get_n_step_info(\n",
    "        self, n_step_buffer: Deque, gamma: float\n",
    "    ) -> Tuple[np.int64, np.ndarray, bool]:\n",
    "        \"\"\"Return n step rew, next_obs, and done.\"\"\"\n",
    "        # info of the last transition\n",
    "        rew, next_obs, done = n_step_buffer[-1][-3:]\n",
    "\n",
    "        for transition in reversed(list(n_step_buffer)[:-1]):\n",
    "            r, n_o, d = transition[-3:]\n",
    "\n",
    "            rew = r + gamma * rew * (1 - d)\n",
    "            next_obs, done = (n_o, d) if d else (next_obs, done)\n",
    "\n",
    "        return rew, next_obs, done\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "\n",
    "We are going to use a simple network architecture with three fully connected layers and two non-linearity functions (ReLU)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(self, in_dim: int, out_dim: int):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(in_dim, 128), \n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128), \n",
    "            nn.ReLU(), \n",
    "            nn.Linear(128, out_dim)\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        return self.layers(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DQN Agent + N-step learning Agent\n",
    "\n",
    "Here is a summary of DQNAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "| ---              | ---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|compute_dqn_loss  | return dqn loss.                                     |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|target_hard_update| hard update from the local model to the target model.|\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |\n",
    "\n",
    "We use two buffers: `memory` and `memory_n` for 1-step transitions and n-step transitions respectively. It guarantees that any paired 1-step and n-step transitions have the same indices (See `step` method for more details). Due to the reason, we can sample pairs of transitions from the two buffers once we have indices for samples.\n",
    "\n",
    "```python\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        ...\n",
    "        samples = self.memory.sample_batch()\n",
    "        indices = samples[\"indices\"]\n",
    "        ...\n",
    "        \n",
    "        # N-step Learning loss\n",
    "        if self.use_n_step:\n",
    "            samples = self.memory_n.sample_batch_from_idxs(indices)\n",
    "            ...\n",
    "```\n",
    "\n",
    "One thing to note that  we are gonna combine 1-step loss and n-step loss so as to control high-variance / high-bias trade-off.\n",
    "\n",
    "(Search the comments with *N-step Leaning* to see any difference from DQN.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): parameter for epsilon greedy policy\n",
    "        epsilon_decay (float): step size to decrease epsilon\n",
    "        max_epsilon (float): max value of epsilon\n",
    "        min_epsilon (float): min value of epsilon\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including \n",
    "                           state, action, reward, next_state, done\n",
    "        use_n_step (bool): whether to use n_step memory\n",
    "        n_step (int): step number to calculate n-step td error\n",
    "        memory_n (ReplayBuffer): n-step replay buffer\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        epsilon_decay: float,\n",
    "        max_epsilon: float = 1.0,\n",
    "        min_epsilon: float = 0.1,\n",
    "        gamma: float = 0.99,\n",
    "        # N-step Learning\n",
    "        n_step: int = 3,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            epsilon_decay (float): step size to decrease epsilon\n",
    "            lr (float): learning rate\n",
    "            max_epsilon (float): max value of epsilon\n",
    "            min_epsilon (float): min value of epsilon\n",
    "            gamma (float): discount factor\n",
    "            n_step (int): step number to calculate n-step td error\n",
    "        \"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        \n",
    "        self.env = env\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = max_epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.min_epsilon = min_epsilon\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # memory for 1-step Learning\n",
    "        self.memory = ReplayBuffer(\n",
    "            obs_dim, memory_size, batch_size, n_step=1\n",
    "        )\n",
    "        \n",
    "        # memory for N-step Learning\n",
    "        self.use_n_step = True if n_step > 1 else False\n",
    "        if self.use_n_step:\n",
    "            self.n_step = n_step\n",
    "            self.memory_n = ReplayBuffer(\n",
    "                obs_dim, memory_size, batch_size, n_step=n_step, gamma=gamma\n",
    "            )\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # epsilon greedy policy\n",
    "        if self.epsilon > np.random.random():\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.dqn(\n",
    "                torch.FloatTensor(state).to(self.device)\n",
    "            ).argmax()\n",
    "            selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "\n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            \n",
    "            # N-step transition\n",
    "            if self.use_n_step:\n",
    "                one_step_transition = self.memory_n.store(*self.transition)\n",
    "            # 1-step transition\n",
    "            else:\n",
    "                one_step_transition = self.transition\n",
    "\n",
    "            # add a single step transition\n",
    "            if one_step_transition:\n",
    "                self.memory.store(*one_step_transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        samples = self.memory.sample_batch()\n",
    "        indices = samples[\"indices\"]\n",
    "        loss = self._compute_dqn_loss(samples, self.gamma)\n",
    "        \n",
    "        # N-step Learning loss\n",
    "        # we are gonna combine 1-step loss and n-step loss so as to\n",
    "        # prevent high-variance.\n",
    "        if self.use_n_step:\n",
    "            samples = self.memory_n.sample_batch_from_idxs(indices)\n",
    "            gamma = self.gamma ** self.n_step\n",
    "            n_loss = self._compute_dqn_loss(samples, gamma)\n",
    "            loss += n_loss\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        update_cnt = 0\n",
    "        epsilons = []\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state = self.env.reset()\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                # linearly decrease epsilon\n",
    "                self.epsilon = max(\n",
    "                    self.min_epsilon, self.epsilon - (\n",
    "                        self.max_epsilon - self.min_epsilon\n",
    "                    ) * self.epsilon_decay\n",
    "                )\n",
    "                epsilons.append(self.epsilon)\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "\n",
    "            # plotting\n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                self._plot(frame_idx, scores, losses, epsilons)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self) -> None:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        while not done:\n",
    "            self.env.render()\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "    \n",
    "    def _compute_dqn_loss(\n",
    "        self, \n",
    "        samples: Dict[str, np.ndarray], \n",
    "        gamma: float\n",
    "    ) -> torch.Tensor:\n",
    "        \"\"\"Return dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "\n",
    "        # G_t   = r + gamma * v(s_{t+1})  if state != Terminal\n",
    "        #       = r                       otherwise\n",
    "        curr_q_value = self.dqn(state).gather(1, action)\n",
    "        next_q_value = self.dqn_target(next_state).max(\n",
    "            dim=1, keepdim=True\n",
    "        )[0].detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + gamma * next_q_value * mask).to(self.device)\n",
    "\n",
    "        # calculate dqn loss\n",
    "        loss = F.smooth_l1_loss(curr_q_value, target)\n",
    "\n",
    "        return loss\n",
    "\n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        losses: List[float], \n",
    "        epsilons: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.subplot(133)\n",
    "        plt.title('epsilons')\n",
    "        plt.plot(epsilons)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "You can see the [code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/cartpole.py) and [configurations](https://github.com/openai/gym/blob/master/gym/envs/__init__.py#L53) of CartPole-v0 from OpenAI's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# environment\n",
    "env_id = \"CartPole-v0\"\n",
    "env = gym.make(env_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[777]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)\n",
    "env.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 20000\n",
    "memory_size = 1000\n",
    "batch_size = 32\n",
    "target_update = 100\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "# train\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  200.0\n"
     ]
    }
   ],
   "source": [
    "agent.env = gym.wrappers.Monitor(env, \"videos\", force=True)\n",
    "agent.test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "videos/openaigym.video.0.14577.video000000.mp4\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <video alt=\"test\" controls>\n",
       "        <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import base64\n",
    "import glob\n",
    "import io\n",
    "import os\n",
    "\n",
    "from IPython.display import HTML, display\n",
    "\n",
    "\n",
    "def ipython_show_video(path: str) -> None:\n",
    "    \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "    if not os.path.isfile(path):\n",
    "        raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "    video = io.open(path, \"r+b\").read()\n",
    "    encoded = base64.b64encode(video)\n",
    "\n",
    "    display(HTML(\n",
    "        data=\"\"\"\n",
    "        <video alt=\"test\" controls>\n",
    "        <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "        </video>\n",
    "        \"\"\".format(encoded.decode(\"ascii\"))\n",
    "    ))\n",
    "\n",
    "list_of_files = glob.glob(\"videos/*.mp4\")\n",
    "latest_file = max(list_of_files, key=os.path.getctime)\n",
    "print(latest_file)\n",
    "ipython_show_video(latest_file)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
